Using LinkedList and Vector Fundamentals in Java

Course: Core Java Training

Topic: Using LinkedList and Vector Fundamentals

Course Link: Core Java Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction

Java provides several collection classes for storing and managing groups of objects. Two important implementations of the List interface are LinkedList and Vector. Both support dynamic collections, preserve element order, allow duplicate values, and provide methods for adding, retrieving, updating, and removing elements.

However, these classes use different internal data structures. LinkedList uses a doubly linked list, whereas Vector uses a growable array. Understanding their differences helps developers choose a suitable data structure for a particular application.

2. Learning Objectives

• Understand the Java List interface and collection hierarchy.
• Learn the fundamentals of the LinkedList class.
• Understand the fundamentals of the Vector class.
• Create, add, retrieve, update, and remove collection elements.
• Use iterators and enhanced for loops to traverse elements.
• Understand LinkedList queue and deque operations.
• Compare LinkedList and Vector performance and memory characteristics.
• Learn about Vector synchronization and thread-safety limitations.
• Apply both classes in practical Java programs.

3. Understanding the List Interface

The List interface belongs to the java.util package. It represents an ordered collection of elements. A list generally allows duplicate values and provides index-based access to its elements.

Both LinkedList and Vector implement the List interface, so they share many operations.

3.1 Important List Features

• Ordered elements: Elements maintain a defined sequence.
• Duplicate values: The same value can appear multiple times.
• Index-based access: Elements can be accessed using positions starting at index zero.
• Dynamic size: Elements can be added or removed after creation.
• Generic types: Generics help restrict the collection to a specified element type.

3.2 Simplified Collection Hierarchy

Iterable<E>
    |
Collection<E>
    |
List<E>
    |
    +-- ArrayList<E>
    +-- LinkedList<E>
    +-- Vector<E>
            |
          Stack<E>

This is a simplified hierarchy. LinkedList also implements Deque and Queue, while Vector implements RandomAccess and supports synchronized individual methods.

4. What Is LinkedList in Java?

4.1 Definition

LinkedList is a class in the java.util package that implements the List, Deque, and Queue interfaces. It stores elements using a doubly linked list structure.

In a doubly linked list, each node contains a reference to the previous node, a reference to the next node, and the stored element. The list maintains references to its first and last nodes.

4.2 Internal Structure of LinkedList

First                                      Last
  |                                          |
  v                                          v
+---------+    +---------+    +---------+
| Node A  |<-->| Node B  |<-->| Node C  |
+---------+    +---------+    +---------+
  previous      previous      previous
  next          next          next

Each node is connected to its neighboring nodes. The diagram is conceptual: the previous and next links connect adjacent nodes in both directions.

4.3 Main Characteristics of LinkedList

• Maintains element order.
• Allows duplicate elements.
• Allows null elements.
• Supports adding and removing elements at either end.
• Supports index-based operations, although accessing an arbitrary index requires traversal.
• Can be used as a list, queue, deque, or stack-style structure.
• Is not synchronized by default.

5. Creating a LinkedList

To use LinkedList, import it from java.util.

import java.util.LinkedList;

public class LinkedListCreation {
    public static void main(String[] args) {
        LinkedList<String> languages = new LinkedList<>();

        languages.add("Java");
        languages.add("Python");
        languages.add("JavaScript");

        System.out.println(languages);
    }
}

Output:

[Java, Python, JavaScript]

The statement new LinkedList<>() creates an empty list of strings. The add() method appends each new element to the end of the list.

6. Adding Elements to LinkedList

LinkedList provides general list operations as well as methods for inserting elements at the beginning and end.

Example: Adding Elements at Different Positions

import java.util.LinkedList;

public class LinkedListAddExample {
    public static void main(String[] args) {
        LinkedList<String> tasks = new LinkedList<>();

        tasks.add("Complete Assignment");
        tasks.add("Attend Meeting");
        tasks.addFirst("Check Emails");
        tasks.addLast("Submit Report");
        tasks.add(2, "Review Code");

        System.out.println(tasks);
    }
}

Output:

[Check Emails, Complete Assignment, Review Code, Attend Meeting, Submit Report]

7. Retrieving Elements from LinkedList

LinkedList provides methods for retrieving elements by index and accessing the first or last element.

import java.util.LinkedList;

public class LinkedListRetrieveExample {
    public static void main(String[] args) {
        LinkedList<String> cities = new LinkedList<>();

        cities.add("Mumbai");
        cities.add("Pune");
        cities.add("Delhi");

        System.out.println("First City: " + cities.getFirst());
        System.out.println("Last City: " + cities.getLast());
        System.out.println("City at Index 1: " + cities.get(1));
    }
}

Output:

First City: Mumbai
Last City: Delhi
City at Index 1: Pune

Important: LinkedList is not an array. Calling get(index) requires traversal from the nearer end, so repeated random access can be slower than with an array-backed list.

8. Updating Elements in LinkedList

The set() method replaces the element at a specified index. It does not insert a new element.

import java.util.LinkedList;

public class LinkedListUpdateExample {
    public static void main(String[] args) {
        LinkedList<String> courses = new LinkedList<>();

        courses.add("Java");
        courses.add("HTML");
        courses.add("Python");

        courses.set(1, "CSS");

        System.out.println(courses);
    }
}

Output:

[Java, CSS, Python]

The element at index 1 changes from HTML to CSS. The list size remains unchanged.

9. Removing Elements from LinkedList

LinkedList supports removal by index, by value, and from either end.

import java.util.LinkedList;

public class LinkedListRemoveExample {
    public static void main(String[] args) {
        LinkedList<String> names = new LinkedList<>();

        names.add("Amit");
        names.add("Priya");
        names.add("Rahul");
        names.add("Neha");

        names.removeFirst();
        names.removeLast();
        names.remove("Rahul");

        System.out.println(names);
    }
}

Output:

[Priya]

Use poll() or pollFirst() when an empty queue is a normal possibility and returning null is appropriate. Use removeFirst() when an empty list should be treated as an error.

10. Traversing a LinkedList

There are several ways to traverse LinkedList elements, depending on whether you need simple iteration, indexes, or iterator-based modifications.

10.1 Using an Enhanced For Loop

import java.util.LinkedList;

public class LinkedListForEachExample {
    public static void main(String[] args) {
        LinkedList<String> fruits = new LinkedList<>();

        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Mango");

        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Output:

Apple
Banana
Mango

10.2 Using an Iterator

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListIteratorExample {
    public static void main(String[] args) {
        LinkedList<Integer> numbers = new LinkedList<>();

        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        Iterator<Integer> iterator = numbers.iterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

Output:

10
20
30

11. LinkedList as a Queue

A queue typically follows the First In, First Out (FIFO) principle. LinkedList implements the Queue interface, allowing elements to be added at the end and removed from the beginning.

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListQueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        queue.offer("Customer 1");
        queue.offer("Customer 2");
        queue.offer("Customer 3");

        System.out.println("Queue: " + queue);
        System.out.println("Next Customer: " + queue.peek());
        System.out.println("Served: " + queue.poll());
        System.out.println("Remaining: " + queue);
    }
}

Output:

Queue: [Customer 1, Customer 2, Customer 3]
Next Customer: Customer 1
Served: Customer 1
Remaining: [Customer 2, Customer 3]

12. LinkedList as a Deque

A deque, or double-ended queue, allows insertion and removal at both the beginning and end. LinkedList implements the Deque interface, so it can be used for queue-like and stack-like operations.

import java.util.Deque;
import java.util.LinkedList;

public class LinkedListDequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new LinkedList<>();

        deque.addFirst("A");
        deque.addLast("B");
        deque.addFirst("C");

        System.out.println("Deque: " + deque);

        deque.removeFirst();
        deque.removeLast();

        System.out.println("After Removal: " + deque);
    }
}

Output:

Deque: [C, A, B]
After Removal: [A]

For a stack or queue in many new applications, ArrayDeque is often a good alternative when null elements are not needed.

13. What Is Vector in Java?

13.1 Definition

Vector is a class in the java.util package that implements the List interface. It stores elements in a growable array and can automatically increase its capacity as more elements are added.

Vector is a legacy collection class that has been part of Java since its early versions. It remains available in modern Java, but many applications use ArrayList when synchronized method behavior is not required.

13.2 Main Characteristics of Vector

• Maintains insertion order.
• Allows duplicate elements.
• Allows null elements.
• Supports index-based access.
• Uses a growable array internally.
• Synchronizes its individual methods.
• Maintains both a logical size and an internal capacity.

14. Understanding Vector Size and Capacity

Two important concepts in Vector are size and capacity.

• Size: The number of elements currently stored.
• Capacity: The number of elements that can be stored in the current internal array before it needs to grow.

A Vector's capacity is always at least as large as its size. Its capacity may be greater than its size because extra array space can be reserved for future additions.

Example

import java.util.Vector;

public class VectorCapacityExample {
    public static void main(String[] args) {
        Vector<String> names = new Vector<>(5);

        names.add("Amit");
        names.add("Neha");

        System.out.println("Size: " + names.size());
        System.out.println("Capacity: " + names.capacity());
    }
}

Output:

Size: 2
Capacity: 5

The constructor sets the initial capacity to five. Since only two elements have been added, the size is two while the capacity remains five.

15. Creating a Vector

Vector supports several constructors for specifying initial capacity or copying elements from another collection.

import java.util.Vector;

public class VectorCreationExample {
    public static void main(String[] args) {
        Vector<String> subjects = new Vector<>();

        subjects.add("Java");
        subjects.add("SQL");
        subjects.add("HTML");

        System.out.println(subjects);
    }
}

Output:

[Java, SQL, HTML]

16. Adding Elements to Vector

Vector provides standard List methods and additional legacy methods for adding elements.

import java.util.Vector;

public class VectorAddExample {
    public static void main(String[] args) {
        Vector<String> products = new Vector<>();

        products.add("Laptop");
        products.add("Mouse");
        products.addElement("Keyboard");
        products.insertElementAt("Monitor", 1);

        System.out.println(products);
    }
}

Output:

[Laptop, Monitor, Mouse, Keyboard]

For code that uses the common List interface, add() and add(index, element) are usually preferred over the older Vector-specific methods.

17. Retrieving Elements from Vector

Vector supports index-based access, along with convenience methods for accessing the first and last elements.

import java.util.Vector;

public class VectorRetrieveExample {
    public static void main(String[] args) {
        Vector<String> colors = new Vector<>();

        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");

        System.out.println("First: " + colors.firstElement());
        System.out.println("Last: " + colors.lastElement());
        System.out.println("Index 1: " + colors.get(1));
        System.out.println("Contains Blue: " + colors.contains("Blue"));
    }
}

Output:

First: Red
Last: Blue
Index 1: Green
Contains Blue: true

18. Updating and Removing Vector Elements

The set() method replaces an element, while removal methods delete elements from the vector.

import java.util.Vector;

public class VectorUpdateRemoveExample {
    public static void main(String[] args) {
        Vector<String> names = new Vector<>();

        names.add("Amit");
        names.add("Priya");
        names.add("Rahul");

        names.set(1, "Sneha");
        names.remove("Rahul");

        System.out.println(names);
    }
}

Output:

[Amit, Sneha]

Common Removal Methods

19. Traversing a Vector

Like other List implementations, Vector can be traversed using an enhanced for loop, an iterator, or an index-based loop.

import java.util.Vector;

public class VectorTraversalExample {
    public static void main(String[] args) {
        Vector<Integer> numbers = new Vector<>();

        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        for (Integer number : numbers) {
            System.out.println(number);
        }
    }
}

Output:

10
20
30

Use an enhanced for loop for straightforward traversal. Use an index-based loop when the position is important or when you need direct indexed access.

20. Understanding Vector Synchronization

One of the main differences between Vector and many modern collection implementations is that Vector synchronizes its individual methods. This means a single method call, such as add() or get(), uses synchronization to coordinate access.

20.1 What Does Synchronization Mean?

Synchronization is a Java mechanism that helps coordinate access to shared mutable data between threads. Vector's synchronized methods can help prevent overlapping execution of individual operations on the same instance.

20.2 Important Limitation

Synchronization of individual methods does not automatically make a multi-step operation atomic. For example, checking whether a Vector contains an element and then adding it may still require a larger synchronized block or another coordination mechanism if the combined operation must be atomic.

import java.util.Vector;

public class VectorSynchronizationExample {
    public static void main(String[] args) {
        Vector<String> sharedData = new Vector<>();

        sharedData.add("Java");
        sharedData.add("SQL");

        synchronized (sharedData) {
            for (String item : sharedData) {
                System.out.println(item);
            }
        }
    }
}

Output:

Java
SQL

The synchronized block holds the Vector's monitor during the traversal. This helps prevent other code that synchronizes on the same Vector from modifying it during the loop. All code accessing the shared structure must follow a compatible locking strategy for this protection to be effective.

21. LinkedList vs. Vector

22. Performance Considerations

Performance depends on the operations performed, the number of elements, and the application's access patterns.

These are general complexity descriptions for common implementations, not guarantees about exact execution time. Real performance also depends on memory allocation, CPU caching, synchronization overhead, and the specific workload.

23. Practical Program: Managing a Task List with LinkedList

This program demonstrates how LinkedList can manage a changing sequence of tasks.

import java.util.LinkedList;

public class TaskManager {
    public static void main(String[] args) {
        LinkedList<String> tasks = new LinkedList<>();

        tasks.add("Study Java");
        tasks.add("Practice SQL");
        tasks.add("Build Project");

        tasks.addFirst("Check Schedule");
        tasks.addLast("Review Notes");

        System.out.println("All Tasks: " + tasks);
        System.out.println("Next Task: " + tasks.getFirst());

        tasks.removeFirst();

        System.out.println("Updated Tasks: " + tasks);
    }
}

Output:

All Tasks: [Check Schedule, Study Java, Practice SQL, Build Project, Review Notes]
Next Task: Check Schedule
Updated Tasks: [Study Java, Practice SQL, Build Project, Review Notes]

Program Explanation

1. Create a LinkedList to store task descriptions.
2. Add the initial tasks using add().
3. Use addFirst() and addLast() to insert tasks at the ends.
4. Use getFirst() to inspect the first task.
5. Use removeFirst() to remove the first task after processing it.

24. Practical Program: Maintaining Student Records with Vector

This example demonstrates how a Vector can store and update a list of student names.

import java.util.Vector;

public class StudentRecords {
    public static void main(String[] args) {
        Vector<String> students = new Vector<>();

        students.add("Aarav");
        students.add("Diya");
        students.add("Kabir");

        students.set(1, "Anaya");

        System.out.println("Student Records:");

        for (String student : students) {
            System.out.println(student);
        }

        System.out.println("Total Students: " + students.size());
        System.out.println("Capacity: " + students.capacity());
    }
}

Output:

Student Records:
Aarav
Anaya
Kabir
Total Students: 3
Capacity: 10

With the no-argument constructor in the standard implementation, the initial capacity is ten. Capacity behavior can be controlled using other constructors and may grow as elements are added.

25. Common Errors and How to Avoid Them

26. Best Practices

• Use generics, such as LinkedList<String> and Vector<Integer>, to improve type safety.
• Prefer the List, Queue, or Deque interface as the variable type when practical.
• Choose LinkedList when its deque operations suit the application and measured performance supports the choice.
• Do not choose LinkedList merely because it is a linked list; frequent indexed access is usually inefficient.
• Prefer ArrayList for many common list use cases that need fast indexed access.
• Use Vector when working with legacy code that relies on its synchronized individual methods.
• For new concurrent applications, evaluate modern concurrent collections when their behavior fits the requirements.
• Remember that synchronized methods do not automatically make multi-step operations atomic.
• Check for empty collections before calling methods that throw exceptions when no element is available.
• Benchmark representative workloads before making performance decisions.

27. Practice Exercises

1. City List: Create a LinkedList of city names, add three more cities, and display all elements.
2. First and Last Elements: Add numbers to a LinkedList and display its first and last elements.
3. Queue Simulation: Use LinkedList as a Queue to process customer requests in FIFO order.
4. Deque Operations: Add and remove elements at both ends of a LinkedList.
5. Vector Update: Store five student names in a Vector and replace one name using set().
6. Vector Capacity: Create a Vector with an initial capacity of 20 and compare its size and capacity before and after adding elements.
7. Search and Remove: Find a specified element in a Vector and remove it if present.
8. Comparison Program: Perform the same insertion, retrieval, and removal operations with LinkedList and Vector, then compare the code and behavior.

28. Mini Project: Help Desk Request Manager

Project Objective

Build a simple help desk request manager using LinkedList. New requests are added to the end of the queue, and the next request is processed from the beginning.

import java.util.LinkedList;
import java.util.Queue;

public class HelpDeskManager {
    public static void main(String[] args) {
        Queue<String> requests = new LinkedList<>();

        requests.offer("Request 101: Login Issue");
        requests.offer("Request 102: Password Reset");
        requests.offer("Request 103: Network Issue");

        System.out.println("Pending Requests: " + requests);

        while (!requests.isEmpty()) {
            String currentRequest = requests.poll();
            System.out.println("Processing: " + currentRequest);
        }

        System.out.println("All requests processed.");
    }
}

Output:

Pending Requests: [Request 101: Login Issue, Request 102: Password Reset, Request 103: Network Issue]
Processing: Request 101: Login Issue
Processing: Request 102: Password Reset
Processing: Request 103: Network Issue
All requests processed.

Project Extension Ideas

• Store request priority and requester information in a custom class.
• Add a method to display the next pending request.
• Allow cancellation of a pending request.
• Use a Vector to store a simple historical list of processed requests.
• Introduce thread coordination if requests are added and processed by multiple threads.

29. Interview Questions and Answers

Q1. What is LinkedList in Java?

LinkedList is a doubly linked list implementation of the List and Deque interfaces. It supports ordered elements, duplicates, and operations at both ends.

Q2. What is Vector in Java?

Vector is a growable-array implementation of the List interface. Its individual methods are synchronized.

Q3. What is the main difference between LinkedList and Vector?

LinkedList stores elements in linked nodes and supports efficient operations at the ends. Vector stores elements in a growable array and provides efficient indexed access.

Q4. Does LinkedList allow duplicate values?

Yes. LinkedList implements the List interface, which permits duplicate values.

Q5. Does Vector allow null values?

Yes. Vector permits null elements, as does LinkedList.

Q6. Why is Vector considered a legacy class?

Vector predates the modern Java Collections Framework and remains available for backward compatibility. Its synchronized methods can be useful in some cases, but many applications use ArrayList instead.

Q7. What is the difference between size and capacity in Vector?

Size is the number of elements currently stored. Capacity is the current amount of internal array storage available before expansion is required.

Q8. Can LinkedList be used as a queue?

Yes. LinkedList implements the Queue and Deque interfaces, so it can support FIFO queue operations.

Q9. Which is faster for indexed access, LinkedList or Vector?

Vector generally provides faster indexed access because it uses an array. LinkedList must traverse nodes to reach an arbitrary index.

Q10. Is Vector completely thread-safe?

Its individual methods are synchronized, but a sequence of multiple operations may still require external synchronization to remain atomic. Iteration also requires care when concurrent modifications are possible.

Q11. What does poll() do in a LinkedList used as a queue?

poll() retrieves and removes the first element. If the queue is empty, it returns null.

Q12. Which collection is suitable for frequent insertions and removals at both ends?

LinkedList supports efficient operations at both ends. ArrayDeque is also worth considering for queue and deque use cases when null elements are not required.

30. Quick Revision Checklist

• Understand the List interface and its basic characteristics.
• Know that LinkedList uses a doubly linked structure.
• Practice LinkedList methods such as addFirst(), addLast(), getFirst(), removeFirst(), and poll().
• Understand how LinkedList supports List, Queue, and Deque operations.
• Know that Vector uses a growable array.
• Understand Vector's size and capacity.
• Practice Vector methods such as add(), get(), set(), remove(), and capacity().
• Remember that Vector synchronizes individual methods but does not make every multi-step operation atomic.
• Compare the access and insertion performance of both classes.
• Choose the collection based on actual application requirements.

31. Conclusion

LinkedList and Vector are useful Java collection classes with different internal designs and strengths. LinkedList uses a doubly linked structure and is suitable for operations at both ends, including queue and deque use cases. Vector uses a growable array, provides fast indexed access, and synchronizes individual methods.

Learning their methods, traversal techniques, performance characteristics, and practical applications helps developers choose appropriate data structures for Java programs. These fundamentals also prepare learners for more advanced topics in the Java Collections Framework, generics, iterators, and concurrent programming.

32. Learn More with JustAcademy

Continue learning Core Java, object-oriented programming, collections, exception handling, and other Java development concepts through the following resources.

• Explore the Core Java Training Course
• Register for a Course Demo
• Visit the JustAcademy Website